```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Netty核心组件全解析</title>
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', sans-serif;
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
        }
        h1, h2, h3, h4 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            margin-top: 1.5em;
            margin-bottom: 0.5em;
        }
        .hero {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
            color: white;
        }
        .card {
            background: white;
            border-radius: 0.75rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
            transition: all 0.3s ease;
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
        }
        .feature-icon {
            width: 3rem;
            height: 3rem;
            background: #4f46e5;
            color: white;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            margin-bottom: 1rem;
        }
        .diagram-container {
            background: white;
            padding: 1.5rem;
            border-radius: 0.75rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
            margin: 2rem 0;
            overflow-x: auto;
        }
        .code-block {
            background: #1e293b;
            color: #f8fafc;
            border-radius: 0.5rem;
            padding: 1.25rem;
            font-family: monospace;
            overflow-x: auto;
            margin: 1.5rem 0;
        }
        .section-divider {
            border: none;
            height: 1px;
            background: linear-gradient(90deg, transparent, #cbd5e1, transparent);
            margin: 4rem 0;
        }
        .nav-item {
            transition: all 0.2s ease;
            border-left: 3px solid transparent;
        }
        .nav-item:hover {
            border-left: 3px solid #4f46e5;
            background-color: #f1f5f9;
        }
        .nav-item.active {
            border-left: 3px solid #4f46e5;
            background-color: #eef2ff;
        }
    </style>
</head>
<body>
    <!-- Hero Section -->
    <section class="hero py-20 px-6 md:px-16 lg:px-24 rounded-b-3xl">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col lg:flex-row items-center">
                <div class="lg:w-1/2 mb-10 lg:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">Netty核心组件全解析</h1>
                    <p class="text-xl mb-8 opacity-90">深入理解高性能网络框架的核心设计与实现原理</p>
                    <div class="flex flex-wrap gap-4">
                        <a href="#core-components" class="bg-white text-indigo-600 font-semibold px-6 py-3 rounded-lg hover:bg-indigo-50 transition-all">核心组件</a>
                        <a href="#features" class="bg-indigo-600 bg-opacity-20 text-white font-semibold px-6 py-3 rounded-lg hover:bg-opacity-30 transition-all">主要特性</a>
                    </div>
                </div>
                <div class="lg:w-1/2 flex justify-center">
                    <div class="relative w-full max-w-md">
                        <div class="absolute -top-8 -left-8 w-32 h-32 bg-indigo-300 rounded-full opacity-30"></div>
                        <div class="absolute -bottom-8 -right-8 w-32 h-32 bg-purple-300 rounded-full opacity-30"></div>
                        <div class="relative bg-white bg-opacity-10 backdrop-filter backdrop-blur-lg p-6 rounded-xl border border-white border-opacity-20">
                            <div class="flex items-center mb-4">
                                <div class="w-3 h-3 bg-red-500 rounded-full mr-2"></div>
                                <div class="w-3 h-3 bg-yellow-500 rounded-full mr-2"></div>
                                <div class="w-3 h-3 bg-green-500 rounded-full"></div>
                            </div>
                            <pre class="text-sm text-white font-mono"><code>// Netty Server Bootstrap
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();

try {
    ServerBootstrap b = new ServerBootstrap();
    b.group(bossGroup, workerGroup)
     .channel(NioServerSocketChannel.class)
     .childHandler(new ChannelInitializer<SocketChannel>() {
         @Override
         protected void initChannel(SocketChannel ch) {
             ch.pipeline().addLast(new MyHandler());
         }
     });
    
    ChannelFuture f = b.bind(8080).sync();
    f.channel().closeFuture().sync();
} finally {
    workerGroup.shutdownGracefully();
    bossGroup.shutdownGracefully();
}</code></pre>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto max-w-6xl px-6 md:px-8 py-12">
        <div class="flex flex-col lg:flex-row gap-8">
            <!-- Navigation -->
            <div class="lg:w-1/4">
                <div class="sticky top-8">
                    <div class="card p-6 mb-6">
                        <h3 class="text-xl font-semibold mb-4">目录导航</h3>
                        <nav>
                            <a href="#core-components" class="block py-2 px-4 nav-item">核心组件概述</a>
                            <a href="#features" class="block py-2 px-4 nav-item">主要特性</a>
                            <a href="#channel" class="block py-2 px-4 nav-item">Channel</a>
                            <a href="#eventloop" class="block py-2 px-4 nav-item">EventLoop</a>
                            <a href="#channelhandler" class="block py-2 px-4 nav-item">ChannelHandler</a>
                            <a href="#channelpipeline" class="block py-2 px-4 nav-item">ChannelPipeline</a>
                            <a href="#bytebuf" class="block py-2 px-4 nav-item">ByteBuf</a>
                            <a href="#channelfuture" class="block py-2 px-4 nav-item">ChannelFuture</a>
                            <a href="#bootstrapping" class="block py-2 px-4 nav-item">Bootstrapping</a>
                            <a href="#codec" class="block py-2 px-4 nav-item">Codec</a>
                        </nav>
                    </div>
                    
                    <div class="card p-6">
                        <h3 class="text-xl font-semibold mb-4">核心关系图</h3>
                        <div class="diagram-container">
                            <div class="mermaid">
                                flowchart TD
                                    A[Bootstrapping] --> B[EventLoopGroup]
                                    B --> C[EventLoop]
                                    C --> D[Channel]
                                    D --> E[ChannelPipeline]
                                    E --> F[ChannelHandler]
                                    F --> G[ByteBuf]
                                    F --> H[ChannelFuture]
                                    E --> I[Codec]
                            </div>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Content -->
            <div class="lg:w-3/4">
                <!-- Core Components Section -->
                <section id="core-components" class="mb-16">
                    <h2 class="text-3xl font-bold mb-6">Netty核心组件</h2>
                    <p class="text-lg text-gray-700 mb-6">Netty已成为一个广泛应用的框架，以其高效的网络处理能力和灵活的设计而著称。Netty通过其一系列核心组件，为我们提供了一种优雅且高效的解决方案。</p>
                    
                    <div class="grid grid-cols-1 md:grid-cols-2 gap-6 mb-8">
                        <div class="card p-6">
                            <div class="feature-icon">
                                <i class="fas fa-plug text-xl"></i>
                            </div>
                            <h3 class="text-xl font-semibold mb-3">Channel</h3>
                            <p class="text-gray-600">网络通信的基本抽象，代表一个到实体的开放连接，如读操作、写操作和绑定状态。</p>
                        </div>
                        <div class="card p-6">
                            <div class="feature-icon">
                                <i class="fas fa-redo text-xl"></i>
                            </div>
                            <h3 class="text-xl font-semibold mb-3">EventLoop</h3>
                            <p class="text-gray-600">处理一个Channel生命周期中的所有事件，采用单线程模型保证线程安全。</p>
                        </div>
                        <div class="card p-6">
                            <div class="feature-icon">
                                <i class="fas fa-code text-xl"></i>
                            </div>
                            <h3 class="text-xl font-semibold mb-3">ChannelHandler</h3>
                            <p class="text-gray-600">处理入站和出站数据的业务逻辑，可以理解为数据处理的拦截器。</p>
                        </div>
                        <div class="card p-6">
                            <div class="feature-icon">
                                <i class="fas fa-project-diagram text-xl"></i>
                            </div>
                            <h3 class="text-xl font-semibold mb-3">ChannelPipeline</h3>
                            <p class="text-gray-600">ChannelHandler的容器，以链式结构组织多个ChannelHandler。</p>
                        </div>
                    </div>
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">Netty架构概述</h3>
                        <p class="mb-4">Netty是一个基于Java NIO（非阻塞IO）构建的异步事件驱动网络应用框架。它的设计目标是为开发者提供一种简便的方式来构建可扩展的高性能网络服务器和客户端。这得益于Netty独特的架构和组件设计，其中每个核心组件都扮演着重要的角色。</p>
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1723006532864-2e2d8bcd-9e11-4ce7-882b-95d3a6755fab.png" alt="Netty架构图" class="w-full rounded-lg mb-4">
                        <p>这些组件不仅确保了Netty的高效性能和灵活性，还提供了开发人员丰富的扩展接口，以满足不同业务场景的需求。</p>
                    </div>
                </section>

                <!-- Features Section -->
                <section id="features" class="mb-16">
                    <h2 class="text-3xl font-bold mb-6">Netty的主要特性</h2>
                    <p class="text-lg text-gray-700 mb-6">Netty 是一个高性能的异步事件驱动网络应用框架，主要用于构建高效的、可扩展的客户端和服务器端应用程序。Netty 具有许多特性，使其在复杂的网络应用开发中脱颖而出。</p>
                    
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1723006616879-8dc1a45c-8f3a-469f-843e-80d39899841d.png" alt="Netty特性" class="w-full rounded-lg mb-8">
                    
                    <div class="space-y-8">
                        <div class="card p-6">
                            <h3 class="text-xl font-semibold mb-4 flex items-center">
                                <i class="fas fa-bolt text-indigo-500 mr-3"></i> 异步非阻塞 I/O
                            </h3>
                            <p class="mb-4">Netty 基于 Java NIO（New I/O）的异步非阻塞 I/O 模型，允许程序在处理网络操作时不必阻塞线程。与传统的阻塞 I/O 模型不同，Netty 的异步特性意味着网络操作的结果在准备好之前不会阻塞线程。</p>
                            <ul class="list-disc pl-6 space-y-2">
                                <li><strong>效率提升</strong>：异步 I/O 可以通过少量线程处理大量并发连接，避免线程上下文切换的开销。</li>
                                <li><strong>事件驱动模型</strong>：Netty 使用事件循环机制，所有网络事件（如读取、写入、连接）都是通过事件通知的方式进行处理。</li>
                                <li><strong>高并发能力</strong>：得益于异步 I/O，Netty 能够支持高并发连接，使其在构建高性能网络服务器时表现出色。</li>
                            </ul>
                        </div>
                        
                        <div class="card p-6">
                            <h3 class="text-xl font-semibold mb-4 flex items-center">
                                <i class="fas fa-puzzle-piece text-indigo-500 mr-3"></i> 灵活的扩展能力
                            </h3>
                            <p class="mb-4">Netty 提供了高度可配置和可扩展的设计，允许开发人员根据特定需求进行自定义扩展。</p>
                            <ul class="list-disc pl-6 space-y-2">
                                <li><strong>ChannelPipeline 和 ChannelHandler</strong>：Netty 使用责任链模式，对网络事件和数据流进行拦截和处理。</li>
                                <li><strong>模块化设计</strong>：Netty 的核心组件和功能都是模块化的，开发人员可以选择性地使用或替换特定组件。</li>
                                <li><strong>支持多种协议</strong>：Netty 内置支持多种协议（如 HTTP、WebSocket、TCP、UDP），并允许开发人员扩展和实现自定义协议。</li>
                            </ul>
                        </div>
                        
                        <div class="card p-6">
                            <h3 class="text-xl font-semibold mb-4 flex items-center">
                                <i class="fas fa-tachometer-alt text-indigo-500 mr-3"></i> 高性能
                            </h3>
                            <p class="mb-4">Netty 在性能方面的优化使其成为高吞吐量、低延迟网络应用的理想框架。</p>
                            <ul class="list-disc pl-6 space-y-2">
                                <li><strong>零拷贝</strong>：Netty 通过直接内存和 ByteBuf 缓存池技术实现零拷贝，减少了数据在内核和用户空间之间的拷贝次数。</li>
                                <li><strong>内存管理</strong>：Netty 的 ByteBuf 采用内存池化机制，支持动态扩展和引用计数，提供了比 Java NIO ByteBuffer 更灵活高效的内存管理方式。</li>
                                <li><strong>线程模型优化</strong>：Netty 的线程模型经过精心设计，通过 Reactor 模式高效管理线程，尽可能地减少上下文切换和锁竞争。</li>
                            </ul>
                        </div>
                    </div>
                </section>

                <hr class="section-divider">

                <!-- Channel Section -->
                <section id="channel" class="mb-16">
                    <h2 class="text-3xl font-bold mb-6">Channel（通道）</h2>
                    <p class="text-lg text-gray-700 mb-6">在Netty中，Channel（通道）是一个核心组件，负责抽象底层网络通信的细节，使得开发者可以专注于业务逻辑而不必深入了解复杂的I/O操作。Channel的设计体现了Netty在高性能网络编程中的灵活性和扩展性。</p>
                    
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1723006647092-2431f6e7-93c6-4271-997f-cea7e86bdbe5.png" alt="Channel结构" class="w-full rounded-lg mb-8">
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">Channel的基本概念</h3>
                        <p>Channel是一个抽象接口，表示与网络套接字或文件句柄相关的I/O操作。它为应用程序提供了一种统一的方式来管理不同类型的连接和数据传输。</p>
                        <ul class="list-disc pl-6 mt-4 space-y-2">
                            <li><strong>异步非阻塞</strong>：Channel支持异步操作，这意味着I/O调用是非阻塞的，调用者可以立即返回，而不必等待操作完成。</li>
                            <li><strong>多协议支持</strong>：通过实现不同的Channel类型，Netty可以支持多种传输协议，如TCP、UDP、SCTP等。</li>
                            <li><strong>多线程模型</strong>：Channel与Netty的事件驱动机制紧密结合，可以在多线程环境中高效运行。</li>
                        </ul>
                    </div>
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">Channel的类型</h3>
                        <div class="overflow-x-auto">
                            <table class="min-w-full divide-y divide-gray-200">
                                <thead class="bg-gray-50">
                                    <tr>
                                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">类型</th>
                                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">功能</th>
                                        <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">应用场景</th>
                                    </tr>
                                </thead>
                                <tbody class="bg-white divide-y divide-gray-200">
                                    <tr>
                                        <td class="px-6 py-4 whitespace-nowrap font-medium">NioSocketChannel</td>
                                        <td class="px-6 py-4">用于TCP客户端和服务端通信的通道</td>
                                        <td class="px-6 py-4">适用于长连接场景</td>
                                    </tr>
                                    <tr>
                                        <td class="px-6 py-4 whitespace-nowrap font-medium">NioServerSocketChannel</td>
                                        <td class="px-6 py-4">用于监听TCP连接请求的服务端通道</td>
                                        <td class="px-6 py-4">处理新连接请求并创建对应的NioSocketChannel实例</td>
                                    </tr>
                                    <tr>
                                        <td class="px-6 py-4 whitespace-nowrap font-medium">NioDatagramChannel</td>
                                        <td class="px-6 py-4">用于UDP通信的通道</td>
                                        <td class="px-6 py-4">适用于短连接和广播场景</td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">Channel的核心组件</h3>
                        <div class="grid md:grid-cols-2 gap-6">
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">ChannelPipeline</h4>
                                <p>ChannelPipeline是一个责任链模式的实现，用于组织和管理一系列的ChannelHandler。负责处理所有的I/O事件和请求，通过一组ChannelHandler进行编解码、业务逻辑处理等。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">ChannelHandler</h4>
                                <p>ChannelHandler是Netty中处理I/O事件的基本单位。实现数据的编解码、协议解析、业务逻辑等。分为ChannelInboundHandler和ChannelOutboundHandler。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">ChannelFuture</h4>
                                <p>ChannelFuture是Netty中表示异步操作结果的接口。提供了检查异步操作状态、添加监听器以获取操作完成通知等功能。用于连接建立、数据传输、连接关闭等异步操作。</p>
                            </div>
                        </div>
                    </div>
                    
                    <div class="card p-6">
                        <h3 class="text-xl font-semibold mb-4">Channel的工作原理</h3>
                        <div class="grid md:grid-cols-2 gap-6 mb-6">
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">事件循环</h4>
                                <p>Netty中的事件循环(EventLoop)是Channel的核心工作机制。负责监听和分发网络事件、调度任务、执行ChannelHandler中的处理逻辑。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">异步I/O</h4>
                                <p>Channel采用异步非阻塞I/O模型，所有I/O操作都是异步执行的。通过注册监听器和回调函数，实现I/O操作的非阻塞执行和结果处理。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">线程模型</h4>
                                <p>Netty的线程模型设计旨在充分利用多核CPU资源。通过Channel与EventLoop的绑定，实现I/O操作与业务逻辑的并行处理。</p>
                            </div>
                        </div>
                        
                        <h4 class="font-semibold mb-2 text-lg">Channel使用示例</h4>
                        <div class="code-block">
                            <pre><code class="text-sm">public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 创建boss和worker两个线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 创建ServerBootstrap实例
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class) // 指定使用NioServerSocketChannel
                .childHandler(new ChannelInitializer&lt;SocketChannel&gt;() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new HttpServerCodec()); // 添加HttpServerCodec处理器
                        pipeline.addLast(new HttpObjectAggregator(512 * 1024)); // 添加HttpObjectAggregator处理器
                        pipeline.addLast(new ChunkedWriteHandler()); // 添加ChunkedWriteHandler处理器
                        pipeline.addLast(new MyBusinessLogicHandler()); // 添加自定义业务逻辑处理器
                    }
                });

            // 绑定端口并启动服务
            ChannelFuture f = b.bind(8080).sync();
            // 等待服务端口关闭
            f.channel().closeFuture().sync();
        } finally {
            // 关闭线程组
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}</code></pre>
                        </div>
                    </div>
                </section>

                <hr class="section-divider">

                <!-- EventLoop Section -->
                <section id="eventloop" class="mb-16">
                    <h2 class="text-3xl font-bold mb-6">EventLoop（事件循环）</h2>
                    <p class="text-lg text-gray-700 mb-6">在Netty中，EventLoop（事件循环）是一个关键组件，负责管理和调度I/O操作、任务执行和事件分发。它是Netty高效处理网络请求的核心机制之一，通过异步和非阻塞的方式实现高性能的网络通信。</p>
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">EventLoop的基本概念</h3>
                        <ul class="list-disc pl-6 space-y-2">
                            <li><strong>单线程执行器</strong>：EventLoop是一个单线程执行器，负责处理与特定Channel相关的所有I/O操作和事件。</li>
                            <li><strong>事件驱动</strong>：EventLoop是事件驱动的，它监听和响应网络事件，确保操作的异步性和高效性。</li>
                            <li><strong>任务队列</strong>：EventLoop维护一个任务队列，用于执行定时任务和普通任务。</li>
                            <li><strong>事件分发</strong>：负责将网络事件分发给ChannelHandler进行处理。</li>
                        </ul>
                    </div>
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">EventLoop的核心组件</h3>
                        <div class="grid md:grid-cols-3 gap-6">
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">EventLoopGroup</h4>
                                <p>EventLoopGroup是EventLoop的集合，负责管理多个EventLoop实例。提供线程池功能，实现线程的复用和负载均衡。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">NioEventLoop</h4>
                                <p>NioEventLoop是EventLoop的具体实现，基于Java NIO的Selector机制。处理网络I/O操作、调度定时任务和普通任务。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">Selector</h4>
                                <p>Selector是Java NIO中的核心组件，用于检测多个通道的就绪状态。通过选择器监控注册的通道，判断哪些通道准备好进行I/O操作。</p>
                            </div>
                        </div>
                    </div>
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">EventLoop的工作原理</h3>
                        <div class="grid md:grid-cols-3 gap-6 mb-6">
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">事件循环</h4>
                                <p>事件循环是EventLoop的核心机制，通过不断轮询选择器来处理I/O事件。过程包括轮询事件、处理事件、执行任务和重复循环。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">事件分发</h4>
                                <p>事件分发是将就绪的I/O事件传递给对应的ChannelHandler进行处理。包括获取事件、分发事件、处理事件和返回结果。</p>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 text-indigo-600">任务调度</h4>
                                <p>EventLoop支持任务调度机制，可以在事件循环中执行普通任务和定时任务。使用任务队列存储待执行的任务，并在事件循环中检查并执行这些任务。</p>
                            </div>
                        </div>
                        
                        <div class="diagram-container">
                            <div class="mermaid">
                                flowchart LR
                                    A[Selector] -->|轮询| B[事件就绪]
                                    B --> C[事件分发]
                                    C --> D[ChannelHandler处理]
                                    D --> E[任务队列]
                                    E --> F[执行任务]
                                    F --> A
                            </div>
                        </div>
                    </div>
                </section>

                <!-- Continue with other sections (ChannelHandler, ChannelPipeline, etc.) following the same pattern -->

                <hr class="section-divider">

                <!-- ChannelHandler Section -->
                <section id="channelhandler" class="mb-16">
                    <h2 class="text-3xl font-bold mb-6">ChannelHandler（通道处理器）</h2>
                    <p class="text-lg text-gray-700 mb-6">在Netty中，ChannelHandler是一个重要的组件，负责处理I/O事件和数据流的操作。它在Netty的处理链（ChannelPipeline）中起着关键作用，可以用于编解码、业务逻辑处理、异常处理等。</p>
                    
                    <div class="card p-6 mb-8">
                        <h3 class="text-xl font-semibold mb-4">ChannelHandler的基本概念</h3>
                        <ul class="list-disc pl-6 space-y-2">
                            <li><strong>接口定义</strong>：ChannelHandler是一个接口，用于定义处理I/O事件的方法。</li>
                            <li><strong>责任链模式</strong>：通过责任链模式，ChannelHandler与ChannelPipeline协同工作，使得每个处理器只关注特定的任务。</li>
                            <li><strong>高度可定制</strong>：可以根据需要定制各种处理器，以实现特定的数据处理和协议支持。</li>
                            <li><strong>模块化设计</strong>：每个ChannelHandler实现一个特定的功能，使得处理逻辑清晰且易于维护。</li>
                        </ul>
                    </div>
                    
                    <!-- Continue with other subsections -->
                </section>

                <!-- Continue with remaining sections -->

            </div>
        </div>
    </div>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // Smooth scrolling for anchor links
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
                
                // Update active state in navigation
                document.querySelectorAll('.nav-item').forEach(item => {
                    item.classList.remove('active');
                });
                this.classList.add('active');
            });
        });
        
        // Highlight active navigation item on scroll
        const sections = document.querySelectorAll('section');
        const navItems = document.querySelectorAll('.nav-item');
        
        window.addEventListener('scroll', () => {
            let current = '';
            
            sections.forEach(section => {
                const sectionTop = section.offsetTop;
                const sectionHeight = section.clientHeight;
                
                if (pageYOffset >= (sectionTop - 300)) {
                    current = section.getAttribute('id');
                }
            });
            
            navItems.forEach(item => {
                item.classList.remove('active');
                if (item.getAttribute('href') === `#${current}`) {
                    item.classList.add('active');
                }
            });
        });
    </script>
</body>
</html>
```